home *** CD-ROM | disk | FTP | other *** search
/ Developer CD Series 1997 July: Mac OS SDK / Dev.CD Jul 97 SDK2.toast / Development Kits (Disc 2) / QuickTime / QuickTime™ 2.5 / Interfaces for Programmers / PInterfaces / MoviesFormat.p < prev    next >
Encoding:
Text File  |  1997-02-26  |  16.2 KB  |  588 lines  |  [TEXT/MPS ]
  1. {
  2.      File:        MoviesFormat.p
  3.  
  4.      Contains:    QuickTime interfaces
  5.  
  6.      Version:    Technology:    
  7.                  Release:    QuickTime 2.5 interfaces to use with ETO #20
  8.  
  9.      Copyright:    © 1984-1996 by Apple Computer, Inc.  All rights reserved.
  10.  
  11.      Bugs?:        If you find a problem with this file, send the file and version
  12.                  information (from above) and the problem description to:
  13.  
  14.                      Internet:    apple.bugs@applelink.apple.com
  15.                      AppleLink:    APPLE.BUGS
  16.  
  17. }
  18. {$IFC UNDEFINED UsingIncludes}
  19. {$SETC UsingIncludes := 0}
  20. {$ENDC}
  21.  
  22. {$IFC NOT UsingIncludes}
  23.  UNIT MoviesFormat;
  24.  INTERFACE
  25. {$ENDC}
  26.  
  27. {$IFC UNDEFINED __MOVIESFORMAT__}
  28. {$SETC __MOVIESFORMAT__ := 1}
  29.  
  30. {$I+}
  31. {$SETC MoviesFormatIncludes := UsingIncludes}
  32. {$SETC UsingIncludes := 1}
  33.  
  34. {$IFC UNDEFINED __TYPES__}
  35. {$I Types.p}
  36. {$ENDC}
  37. {$IFC UNDEFINED __WINDOWS__}
  38. {$I Windows.p}
  39. {$ENDC}
  40. {$IFC UNDEFINED __IMAGECOMPRESSION__}
  41. {$I ImageCompression.p}
  42. {$ENDC}
  43. {$IFC UNDEFINED __MOVIES__}
  44. {$I Movies.p}
  45. {$ENDC}
  46.  
  47. {$PUSH}
  48. {$ALIGN MAC68K}
  49. {$LibExport+}
  50.  
  51.  
  52. CONST
  53.     kMovieVersion                = 0;                            {  version number of the format here described  }
  54.  
  55. {
  56. ***************************************
  57. *
  58. *   General Types -
  59. *        These types are used in more than one of the
  60. *        directory types.
  61. *
  62. ***************************************
  63. }
  64.  
  65. TYPE
  66.     MoviesUserDataPtr = ^MoviesUserData;
  67.     MoviesUserData = RECORD
  68.         size:                    LONGINT;                                {  size of this user data  }
  69.         udType:                    LONGINT;                                {  type of user data  }
  70.         data:                    SInt8;                                    {  the user data  }
  71.     END;
  72.  
  73.     UserDataAtomPtr = ^UserDataAtom;
  74.     UserDataAtom = RECORD
  75.         size:                    LONGINT;
  76.         atomType:                LONGINT;
  77.         userData:                ARRAY [0..0] OF MoviesUserData;
  78.     END;
  79.  
  80. {
  81.  MoviesDataDescription tells us where the data for the movie or track lives.
  82.    The data can follow the directory, be in the datafork of the same file as the directory resource,
  83.    be in the resource fork of the same file as the directory resource, be in another file in the
  84.    data fork or resource fork, or require a specific bottleneck to fetch the data. 
  85. }
  86. {
  87. ***************************************
  88. *
  89. *   MediaDirectory information -
  90. *        The MediaDirectory is tightly coupled to the data.
  91. *
  92. ***************************************
  93. }
  94.     SampleDescriptionAtomPtr = ^SampleDescriptionAtom;
  95.     SampleDescriptionAtom = RECORD
  96.         size:                    LONGINT;
  97.         atomType:                LONGINT;                                {  = 'stsd'  }
  98.         flags:                    LONGINT;                                {  1 byte of version / 3 bytes of flags  }
  99.         numEntries:                LONGINT;
  100.         sampleDescTable:        ARRAY [0..0] OF SampleDescription;
  101.     END;
  102.  
  103. {  TimeToSampleNum maps physical sample time to physical sample number.  }
  104.     TimeToSampleNumPtr = ^TimeToSampleNum;
  105.     TimeToSampleNum = RECORD
  106.         sampleCount:            LONGINT;
  107.         sampleDuration:            TimeValue;
  108.     END;
  109.  
  110.     TimeToSampleNumAtomPtr = ^TimeToSampleNumAtom;
  111.     TimeToSampleNumAtom = RECORD
  112.         size:                    LONGINT;
  113.         atomType:                LONGINT;                                {  = 'stts'  }
  114.         flags:                    LONGINT;                                {  1 byte of version / 3 bytes of flags  }
  115.         numEntries:                LONGINT;
  116.         timeToSampleNumTable:    ARRAY [0..0] OF TimeToSampleNum;
  117.     END;
  118.  
  119. {  SyncSamples is a list of the physical samples which are self contained.  }
  120.     SyncSampleAtomPtr = ^SyncSampleAtom;
  121.     SyncSampleAtom = RECORD
  122.         size:                    LONGINT;
  123.         atomType:                LONGINT;                                {  = 'stss'  }
  124.         flags:                    LONGINT;                                {  1 byte of version / 3 bytes of flags  }
  125.         numEntries:                LONGINT;
  126.         syncSampleTable:        ARRAY [0..0] OF LONGINT;
  127.     END;
  128.  
  129. {  SampleToChunk maps physical sample number to chunk number.  }
  130. {  same as SampleToChunk, but redundant first sample is removed  }
  131.     SampleToChunkPtr = ^SampleToChunk;
  132.     SampleToChunk = RECORD
  133.         firstChunk:                LONGINT;
  134.         samplesPerChunk:        LONGINT;
  135.         sampleDescriptionID:    LONGINT;
  136.     END;
  137.  
  138.     SampleToChunkAtomPtr = ^SampleToChunkAtom;
  139.     SampleToChunkAtom = RECORD
  140.         size:                    LONGINT;
  141.         atomType:                LONGINT;                                {  = 'stsc'  }
  142.         flags:                    LONGINT;                                {  1 byte of version / 3 bytes of flags  }
  143.         numEntries:                LONGINT;
  144.         sampleToChunkTable:        ARRAY [0..0] OF SampleToChunk;
  145.     END;
  146.  
  147.     ChunkOffsetAtomPtr = ^ChunkOffsetAtom;
  148.     ChunkOffsetAtom = RECORD
  149.         size:                    LONGINT;
  150.         atomType:                LONGINT;                                {  = 'stco'  }
  151.         flags:                    LONGINT;                                {  1 byte of version / 3 bytes of flags  }
  152.         numEntries:                LONGINT;
  153.         chunkOffsetTable:        ARRAY [0..0] OF LONGINT;
  154.     END;
  155.  
  156.     SampleSizeAtomPtr = ^SampleSizeAtom;
  157.     SampleSizeAtom = RECORD
  158.         size:                    LONGINT;
  159.         atomType:                LONGINT;                                {  = 'stsz'  }
  160.         flags:                    LONGINT;                                {  1 byte of version / 3 bytes of flags  }
  161.         sampleSize:                LONGINT;
  162.         numEntries:                LONGINT;
  163.         sampleSizeTable:        ARRAY [0..0] OF LONGINT;
  164.     END;
  165.  
  166.     ShadowSyncPtr = ^ShadowSync;
  167.     ShadowSync = RECORD
  168.         fdSampleNum:            LONGINT;
  169.         syncSampleNum:            LONGINT;
  170.     END;
  171.  
  172.     ShadowSyncAtomPtr = ^ShadowSyncAtom;
  173.     ShadowSyncAtom = RECORD
  174.         size:                    LONGINT;
  175.         atomType:                LONGINT;                                {  = 'stsz'  }
  176.         flags:                    LONGINT;                                {  1 byte of version / 3 bytes of flags  }
  177.         numEntries:                LONGINT;
  178.         shadowSyncTable:        ARRAY [0..0] OF ShadowSync;
  179.     END;
  180.  
  181.     SampleTableAtomPtr = ^SampleTableAtom;
  182.     SampleTableAtom = RECORD
  183.         size:                    LONGINT;
  184.         atomType:                LONGINT;                                {  = 'stbl'  }
  185.         sampleDescription:        SampleDescriptionAtom;
  186.         timeToSampleNum:        TimeToSampleNumAtom;
  187.         sampleToChunk:            SampleToChunkAtom;
  188.         syncSample:                SyncSampleAtom;
  189.         sampleSize:                SampleSizeAtom;
  190.         chunkOffset:            ChunkOffsetAtom;
  191.         shadowSync:                ShadowSyncAtom;
  192.     END;
  193.  
  194.     PublicHandlerInfoPtr = ^PublicHandlerInfo;
  195.     PublicHandlerInfo = RECORD
  196.         flags:                    LONGINT;                                {  1 byte of version / 3 bytes of flags  }
  197.         componentType:            LONGINT;
  198.         componentSubType:        LONGINT;
  199.         componentManufacturer:    LONGINT;
  200.         componentFlags:            LONGINT;
  201.         componentFlagsMask:        LONGINT;
  202.         componentName:            SInt8;
  203.     END;
  204.  
  205.     HandlerAtomPtr = ^HandlerAtom;
  206.     HandlerAtom = RECORD
  207.         size:                    LONGINT;
  208.         atomType:                LONGINT;                                {  = 'hdlr'  }
  209.         hInfo:                    PublicHandlerInfo;
  210.     END;
  211.  
  212. {  a data reference is a private structure  }
  213.     DataRefAtom                            = LONGINT;
  214.     DataInfoAtomPtr = ^DataInfoAtom;
  215.     DataInfoAtom = RECORD
  216.         size:                    LONGINT;
  217.         atomType:                LONGINT;                                {  = 'dinf'  }
  218.         dataRef:                DataRefAtom;
  219.     END;
  220.  
  221.     RgnAtomPtr = ^RgnAtom;
  222.     RgnAtom = RECORD
  223.         size:                    LONGINT;
  224.         atomType:                LONGINT;
  225.         rgnSize:                INTEGER;
  226.         rgnBBox:                Rect;
  227.         data:                    SInt8;
  228.     END;
  229.  
  230.     MatteCompressedAtomPtr = ^MatteCompressedAtom;
  231.     MatteCompressedAtom = RECORD
  232.         size:                    LONGINT;
  233.         atomType:                LONGINT;
  234.         flags:                    LONGINT;                                {  1 byte of version / 3 bytes of flags  }
  235.         matteImageDescription:    ImageDescription;
  236.         matteData:                SInt8;
  237.     END;
  238.  
  239.     MatteAtomPtr = ^MatteAtom;
  240.     MatteAtom = RECORD
  241.         size:                    LONGINT;
  242.         atomType:                LONGINT;
  243.         aCompressedMatte:        MatteCompressedAtom;
  244.     END;
  245.  
  246.     ClippingAtomPtr = ^ClippingAtom;
  247.     ClippingAtom = RECORD
  248.         size:                    LONGINT;
  249.         atomType:                LONGINT;
  250.         aRgnClip:                RgnAtom;
  251.     END;
  252.  
  253. {
  254. **********************
  255. * Media Info Example Structures
  256. **********************
  257. }
  258.     VideoMediaInfoHeaderPtr = ^VideoMediaInfoHeader;
  259.     VideoMediaInfoHeader = RECORD
  260.         flags:                    LONGINT;                                {  1 byte of version / 3 bytes of flags  }
  261.         graphicsMode:            INTEGER;                                {  for QD - transfer mode  }
  262.         opColorRed:                INTEGER;                                {  opcolor for transfer mode  }
  263.         opColorGreen:            INTEGER;
  264.         opColorBlue:            INTEGER;
  265.     END;
  266.  
  267.     VideoMediaInfoHeaderAtomPtr = ^VideoMediaInfoHeaderAtom;
  268.     VideoMediaInfoHeaderAtom = RECORD
  269.         size:                    LONGINT;                                {  size of Media info  }
  270.         atomType:                LONGINT;                                {  = 'vmhd'  }
  271.         vmiHeader:                VideoMediaInfoHeader;
  272.     END;
  273.  
  274.     VideoMediaInfoPtr = ^VideoMediaInfo;
  275.     VideoMediaInfo = RECORD
  276.         size:                    LONGINT;                                {  size of Media info  }
  277.         atomType:                LONGINT;                                {  = 'minf'  }
  278.         header:                    VideoMediaInfoHeaderAtom;
  279.         dataHandler:            HandlerAtom;
  280.         dataInfo:                DataInfoAtom;
  281.         sampleTable:            SampleTableAtom;
  282.     END;
  283.  
  284.     SoundMediaInfoHeaderPtr = ^SoundMediaInfoHeader;
  285.     SoundMediaInfoHeader = RECORD
  286.         flags:                    LONGINT;                                {  1 byte of version / 3 bytes of flags  }
  287.         balance:                INTEGER;
  288.         rsrvd:                    INTEGER;
  289.     END;
  290.  
  291.     SoundMediaInfoHeaderAtomPtr = ^SoundMediaInfoHeaderAtom;
  292.     SoundMediaInfoHeaderAtom = RECORD
  293.         size:                    LONGINT;                                {  size of Media info  }
  294.         atomType:                LONGINT;                                {  = 'vmhd'  }
  295.         smiHeader:                SoundMediaInfoHeader;
  296.     END;
  297.  
  298.     SoundMediaInfoPtr = ^SoundMediaInfo;
  299.     SoundMediaInfo = RECORD
  300.         size:                    LONGINT;                                {  size of Media info  }
  301.         atomType:                LONGINT;                                {  = 'minf'  }
  302.         header:                    SoundMediaInfoHeaderAtom;
  303.         dataHandler:            HandlerAtom;
  304.         dataReference:            DataRefAtom;
  305.         sampleTable:            SampleTableAtom;
  306.     END;
  307.  
  308. {  whatever data the media handler needs goes after the atomType  }
  309.     MediaInfoPtr = ^MediaInfo;
  310.     MediaInfo = RECORD
  311.         size:                    LONGINT;
  312.         atomType:                LONGINT;
  313.     END;
  314.  
  315. {
  316. **********************
  317. * Media Directory Structures
  318. **********************
  319. }
  320.     MediaHeaderPtr = ^MediaHeader;
  321.     MediaHeader = RECORD
  322.         flags:                    LONGINT;                                {  1 byte of version / 3 bytes of flags  }
  323.         creationTime:            LONGINT;                                {  seconds since Jan 1904 when directory was created  }
  324.         modificationTime:        LONGINT;                                {  seconds since Jan 1904 when directory was appended  }
  325.         timeScale:                TimeValue;                                {  start time for Media (Media time)  }
  326.         duration:                TimeValue;                                {  length of Media (Media time)  }
  327.         language:                INTEGER;
  328.         quality:                INTEGER;
  329.     END;
  330.  
  331.     MediaHeaderAtomPtr = ^MediaHeaderAtom;
  332.     MediaHeaderAtom = RECORD
  333.         size:                    LONGINT;
  334.         atomType:                LONGINT;
  335.         header:                    MediaHeader;
  336.     END;
  337.  
  338.     MediaDirectoryPtr = ^MediaDirectory;
  339.     MediaDirectory = RECORD
  340.         size:                    LONGINT;
  341.         atomType:                LONGINT;                                {  = 'mdia'  }
  342.         mediaHeader:            MediaHeaderAtom;                        {  standard Media information  }
  343.         mediaHandler:            HandlerAtom;
  344.         mediaInfo:                MediaInfo;
  345.     END;
  346.  
  347. {
  348. **********************
  349. * Track Structures
  350. **********************
  351. }
  352.  
  353. CONST
  354.     TrackEnable                    = $01;
  355.     TrackInMovie                = $02;
  356.     TrackInPreview                = $04;
  357.     TrackInPoster                = $08;
  358.  
  359.  
  360. TYPE
  361.     TrackHeaderPtr = ^TrackHeader;
  362.     TrackHeader = RECORD
  363.         flags:                    LONGINT;                                {  1 byte of version / 3 bytes of flags  }
  364.         creationTime:            LONGINT;                                {  seconds since Jan 1904 when directory was created  }
  365.         modificationTime:        LONGINT;                                {  seconds since Jan 1904 when directory was appended  }
  366.         trackID:                LONGINT;
  367.         reserved1:                LONGINT;
  368.         duration:                TimeValue;                                {  length of track (track time)  }
  369.         reserved2:                LONGINT;
  370.         reserved3:                LONGINT;
  371.         layer:                    INTEGER;
  372.         alternateGroup:            INTEGER;
  373.         volume:                    INTEGER;
  374.         reserved4:                INTEGER;
  375.         matrix:                    MatrixRecord;
  376.         trackWidth:                Fixed;
  377.         trackHeight:            Fixed;
  378.     END;
  379.  
  380.     TrackHeaderAtomPtr = ^TrackHeaderAtom;
  381.     TrackHeaderAtom = RECORD
  382.         size:                    LONGINT;                                {  size of track header  }
  383.         atomType:                LONGINT;                                {  = 'tkhd'  }
  384.         header:                    TrackHeader;
  385.     END;
  386.  
  387.     EditListTypePtr = ^EditListType;
  388.     EditListType = RECORD
  389.         trackDuration:            TimeValue;
  390.         mediaTime:                TimeValue;
  391.         mediaRate:                Fixed;
  392.     END;
  393.  
  394.     EditListAtomPtr = ^EditListAtom;
  395.     EditListAtom = RECORD
  396.         size:                    LONGINT;
  397.         atomType:                LONGINT;                                {  = elst  }
  398.         flags:                    LONGINT;                                {  1 byte of version / 3 bytes of flags  }
  399.         numEntries:                LONGINT;
  400.         editListTable:            ARRAY [0..0] OF EditListType;
  401.     END;
  402.  
  403.     EditsAtomPtr = ^EditsAtom;
  404.     EditsAtom = RECORD
  405.         size:                    LONGINT;
  406.         atomType:                LONGINT;                                {  = edts  }
  407.         editList:                EditListAtom;
  408.     END;
  409.  
  410.     TrackLoadSettingsPtr = ^TrackLoadSettings;
  411.     TrackLoadSettings = RECORD
  412.         preloadStartTime:        TimeValue;
  413.         preloadDuration:        TimeValue;
  414.         preloadFlags:            LONGINT;
  415.         defaultHints:            LONGINT;
  416.     END;
  417.  
  418.     TrackLoadSettingsAtomPtr = ^TrackLoadSettingsAtom;
  419.     TrackLoadSettingsAtom = RECORD
  420.         size:                    LONGINT;
  421.         atomType:                LONGINT;                                {  = load  }
  422.         settings:                TrackLoadSettings;
  423.     END;
  424.  
  425.     TrackDirectoryPtr = ^TrackDirectory;
  426.     TrackDirectory = RECORD
  427.         size:                    LONGINT;
  428.         atomType:                LONGINT;                                {  = 'trak'  }
  429.         trackHeader:            TrackHeaderAtom;                        {  standard track information  }
  430.         trackClip:                ClippingAtom;
  431.         edits:                    EditsAtom;
  432.         media:                    MediaDirectory;
  433.         userData:                UserDataAtom;                            {  space for extending with new data types  }
  434.     END;
  435.  
  436. {
  437. ***************************************
  438. *
  439. *   MovieDirectory -
  440. *        The MovieDirectory is the top level structure which
  441. *        holds the TrackInstance describing where the
  442. *        TrackDirectories are.
  443. *
  444. ***************************************
  445. }
  446.     MovieHeaderPtr = ^MovieHeader;
  447.     MovieHeader = RECORD
  448.         flags:                    LONGINT;                                {  1 byte of version / 3 bytes of flags  }
  449.         creationTime:            LONGINT;                                {  seconds since Jan 1904 when directory was created  }
  450.         modificationTime:        LONGINT;                                {  seconds since Jan 1904 when directory was appended  }
  451.         timeScale:                TimeValue;                                {  Time specifications  }
  452.         duration:                TimeValue;
  453.         preferredRate:            Fixed;                                    {  rate at which to play this movie  }
  454.         preferredVolume:        INTEGER;                                {  volume to play movie at  }
  455.         reserved1:                INTEGER;
  456.         preferredLong1:            LONGINT;
  457.         preferredLong2:            LONGINT;
  458.         matrix:                    MatrixRecord;
  459.         previewTime:            TimeValue;                                {  time in track the proxy begins (track time)  }
  460.         previewDuration:        TimeValue;                                {  how long the proxy lasts (track time)  }
  461.         posterTime:                TimeValue;                                {  time in track the proxy begins (track time)  }
  462.         selectionTime:            TimeValue;                                {  time in track the proxy begins (track time)  }
  463.         selectionDuration:        TimeValue;                                {  time in track the proxy begins (track time)  }
  464.         currentTime:            TimeValue;                                {  time in track the proxy begins (track time)  }
  465.         nextTrackID:            LONGINT;                                {  next value to use for a TrackID  }
  466.     END;
  467.  
  468.     MovieHeaderAtomPtr = ^MovieHeaderAtom;
  469.     MovieHeaderAtom = RECORD
  470.         size:                    LONGINT;
  471.         atomType:                LONGINT;                                {  = 'mvhd'  }
  472.         header:                    MovieHeader;
  473.     END;
  474.  
  475.     TrackDirectoryEntryPtr = ^TrackDirectoryEntry;
  476.     TrackDirectoryEntry = RECORD
  477.         trackDirectory:            TrackDirectory;                            {  Track directory information  }
  478.     END;
  479.  
  480.     MovieDirectoryPtr = ^MovieDirectory;
  481.     MovieDirectory = RECORD
  482.         size:                    LONGINT;
  483.         atomType:                LONGINT;                                {  = 'moov'  }
  484.         header:                    MovieHeaderAtom;
  485.         movieClip:                ClippingAtom;
  486.                                                                         {  Track Directories  }
  487.         track:                    ARRAY [0..0] OF TrackDirectoryEntry;    {  Track directory information  }
  488.                                                                         {  User data for Movie  }
  489.         userData:                UserDataAtom;                            {  space for user extensions  }
  490.     END;
  491.  
  492. {
  493. ***************************************
  494. ***************************************
  495. }
  496. {  Movie formats and tags  }
  497.  
  498. CONST
  499.                                                                 {  some system defined format IDs  }
  500.     MOVIE_TYPE                    = 'moov';
  501.     TRACK_TYPE                    = 'trak';
  502.     MEDIA_TYPE                    = 'mdia';
  503.     VIDEO_TYPE                    = 'vide';
  504.     SOUND_TYPE                    = 'soun';
  505.  
  506. {  atom id's  }
  507.     MovieAID                    = 'moov';
  508.     MovieHeaderAID                = 'mvhd';
  509.     ClipAID                        = 'clip';
  510.     RgnClipAID                    = 'crgn';
  511.     MatteAID                    = 'matt';
  512.     MatteCompAID                = 'kmat';
  513.     TrackAID                    = 'trak';
  514.     UserDataAID                    = 'udta';
  515.     TrackHeaderAID                = 'tkhd';
  516.     EditsAID                    = 'edts';
  517.     EditListAID                    = 'elst';
  518.     MediaAID                    = 'mdia';
  519.     MediaHeaderAID                = 'mdhd';
  520.     MediaInfoAID                = 'minf';
  521.     VideoMediaInfoHeaderAID        = 'vmhd';
  522.     SoundMediaInfoHeaderAID        = 'smhd';
  523.     GenericMediaInfoHeaderAID    = 'gmhd';
  524.     GenericMediaInfoAID            = 'gmin';
  525.     DataInfoAID                    = 'dinf';
  526.     DataRefAID                    = 'dref';
  527.     SampleTableAID                = 'stbl';
  528.     STSampleDescAID                = 'stsd';
  529.     STTimeToSampAID                = 'stts';
  530.     STSyncSampleAID                = 'stss';
  531.     STSampleToChunkAID            = 'stsc';
  532.     STShadowSyncAID                = 'stsh';
  533.     HandlerAID                    = 'hdlr';
  534.     STSampleSizeAID                = 'stsz';
  535.     STChunkOffsetAID            = 'stco';
  536.     STChunkOffset64AID            = 'co64';
  537.     DataRefContainerAID            = 'drfc';
  538.     TrackReferenceAID            = 'tref';
  539.     ColorTableAID                = 'ctab';
  540.     LoadSettingsAID                = 'load';
  541.     PropertyAtomAID                = 'code';
  542.     InputMapAID                    = 'imap';
  543.     MovieBufferHintsAID            = 'mbfh';
  544.     MovieDataRefAliasAID        = 'mdra';
  545.     SoundLocalizationAID        = 'sloc';
  546.  
  547. {  Text ATOM definitions }
  548.  
  549. TYPE
  550.     TextBoxAtomPtr = ^TextBoxAtom;
  551.     TextBoxAtom = RECORD
  552.         size:                    LONGINT;
  553.         atomType:                LONGINT;                                {  = 'tbox'  }
  554.         textBox:                Rect;                                    {  New text box (overrides defaultTextBox) }
  555.     END;
  556.  
  557.     HiliteAtomPtr = ^HiliteAtom;
  558.     HiliteAtom = RECORD
  559.         size:                    LONGINT;
  560.         atomType:                LONGINT;                                {  = 'hlit'  }
  561.         selStart:                LONGINT;                                {  hilite selection start character }
  562.         selEnd:                    LONGINT;                                {  hilite selection end character }
  563.     END;
  564.  
  565.     KaraokeRecPtr = ^KaraokeRec;
  566.     KaraokeRec = RECORD
  567.         timeVal:                TimeValue;
  568.         beginHilite:            INTEGER;
  569.         endHilite:                INTEGER;
  570.     END;
  571.  
  572.     KaraokeAtomPtr = ^KaraokeAtom;
  573.     KaraokeAtom = RECORD
  574.         numEntries:                LONGINT;
  575.         karaokeEntries:            ARRAY [0..0] OF KaraokeRec;
  576.     END;
  577.  
  578. {$ALIGN RESET}
  579. {$POP}
  580.  
  581. {$SETC UsingIncludes := MoviesFormatIncludes}
  582.  
  583. {$ENDC} {__MOVIESFORMAT__}
  584.  
  585. {$IFC NOT UsingIncludes}
  586.  END.
  587. {$ENDC}
  588.